// 网络请求封装
const BASE_URL = 'https://api.example.com'

// 请求拦截器
const requestInterceptor = (config) => {
  // 添加token到请求头
  const token = uni.getStorageSync('token')
  if (token) {
    config.header = config.header || {}
    config.header['Authorization'] = `Bearer ${token}`
  }
  
  // 如果是formData请求，设置正确的Content-Type
  if (config.formData) {
    config.header = config.header || {}
    // 注意：在uni-app中，使用FormData时不需要手动设置Content-Type，框架会自动处理
  }
  
  // 添加公共参数
  if (config.method === 'GET') {
    config.data = config.data || {}
    config.data.t = Date.now()
  }
  
  // 显示加载中
  if (config.loading !== false) {
    uni.showLoading({
      title: '加载中...',
      mask: true
    })
  }
  
  return config
}

// 响应拦截器
const responseInterceptor = (response) => {
  // 隐藏加载中
  uni.hideLoading()
  
  const { data, statusCode } = response
  
  if (statusCode === 200) {
    // 统一处理业务逻辑错误
    if (data.code === 401) {
      // token失效，跳转到登录页
      uni.removeStorageSync('token')
      uni.showToast({
        title: '登录已过期，请重新登录',
        icon: 'none'
      })
      setTimeout(() => {
        uni.reLaunch({
          url: '/pages/login/login'
        })
      }, 1500)
      return Promise.reject(new Error('登录已过期'))
    }
    
    return data
  } else {
    // 处理HTTP错误
    uni.showToast({
      title: `请求失败(${statusCode})`,
      icon: 'none'
    })
    return Promise.reject(new Error(`HTTP错误: ${statusCode}`))
  }
}

// 错误处理
const errorHandler = (error) => {
  uni.hideLoading()
  
  const { errMsg } = error
  if (errMsg) {
    if (errMsg.includes('request:fail')) {
      uni.showToast({
        title: '网络连接失败，请检查网络',
        icon: 'none'
      })
    } else {
      uni.showToast({
        title: errMsg,
        icon: 'none'
      })
    }
  }
  
  return Promise.reject(error)
}

// 封装uni.request
export const request = (url, options = {}) => {
  // 拼接完整URL
  const fullUrl = url.startsWith('http') ? url : BASE_URL + url
  
  // 合并配置
  const config = {
    url: fullUrl,
    method: options.method || 'GET',
    data: options.data || {},
    header: options.header || {},
    loading: options.loading !== false,
    formData: options.formData || false
  }
  
  // 应用请求拦截器
  try {
    const processedConfig = requestInterceptor(config)
    
    // 发送请求
    return new Promise((resolve, reject) => {
      uni.request({
        ...processedConfig,
        success: (response) => {
          try {
            const processedResponse = responseInterceptor(response)
            resolve(processedResponse)
          } catch (err) {
            reject(err)
          }
        },
        fail: (error) => {
          reject(errorHandler(error))
        }
      })
    })
  } catch (err) {
    return Promise.reject(err)
  }
}

// 封装GET请求
export const get = (url, data = {}, options = {}) => {
  return request(url, {
    method: 'GET',
    data,
    ...options
  })
}

// 封装POST请求
export const post = (url, data = {}, options = {}) => {
  return request(url, {
    method: 'POST',
    data,
    ...options
  })
}

// 封装FormData格式的POST请求
export const postFormData = (url, formData, options = {}) => {
  // 在uni-app中，我们可以直接传递对象作为formdata
  // 框架会自动处理Content-Type和数据格式转换
  return request(url, {
    method: 'POST',
    data: formData,
    formData: true,
    ...options
  })
}

// 封装文件上传请求
export const uploadFile = (url, filePath, options = {}) => {
  // 拼接完整URL
  const fullUrl = url.startsWith('http') ? url : BASE_URL + url
  
  // 显示加载中
  if (options.loading !== false) {
    uni.showLoading({
      title: '上传中...',
      mask: true
    })
  }
  
  return new Promise((resolve, reject) => {
    const token = uni.getStorageSync('token')
    
    // 调用uni.uploadFile上传文件
    uni.uploadFile({
      url: fullUrl,
      filePath: filePath,
      name: options.name || 'file', // 文件对应的 key
      formData: options.formData || {}, // 其他表单参数
      header: {
        'Authorization': token ? `Bearer ${token}` : '',
        ...options.header
      },
      success: (res) => {
        // 隐藏加载中
        if (options.loading !== false) {
          uni.hideLoading()
        }
        
        try {
          // 解析响应数据
          const responseData = JSON.parse(res.data)
          
          if (res.statusCode === 200) {
            // 统一处理业务逻辑错误
            if (responseData.code === 401) {
              // token失效，跳转到登录页
              uni.removeStorageSync('token')
              uni.showToast({
                title: '登录已过期，请重新登录',
                icon: 'none'
              })
              setTimeout(() => {
                uni.reLaunch({
                  url: '/pages/login/login'
                })
              }, 1500)
              return reject(new Error('登录已过期'))
            }
            
            resolve(responseData)
          } else {
            // 处理HTTP错误
            const errorMsg = responseData.msg || `文件上传失败(${res.statusCode})`
            uni.showToast({
              title: errorMsg,
              icon: 'none'
            })
            reject(new Error(errorMsg))
          }
        } catch (e) {
          const errorMsg = '文件上传失败，响应数据格式错误'
          uni.showToast({
            title: errorMsg,
            icon: 'none'
          })
          reject(new Error(errorMsg))
        }
      },
      fail: (error) => {
        // 隐藏加载中
        if (options.loading !== false) {
          uni.hideLoading()
        }
        
        // 处理上传失败
        const errorMsg = error.errMsg || '文件上传失败'
        uni.showToast({
          title: errorMsg,
          icon: 'none'
        })
        reject(error)
      },
      // 可选的进度回调
      ...(options.onProgressUpdate ? { onProgressUpdate: options.onProgressUpdate } : {})
    })
  })
}

// 封装文件下载请求
export const downloadFile = (url, options = {}) => {
  // 拼接完整URL
  let fullUrl = url.startsWith('http') ? url : BASE_URL + url
  
  // 如果有参数，拼接到URL
  if (options.params) {
    const params = new URLSearchParams()
    Object.keys(options.params).forEach(key => {
      params.append(key, options.params[key])
    })
    fullUrl += '?' + params.toString()
  }
  
  // 显示加载中
  if (options.loading !== false) {
    uni.showLoading({
      title: '文件下载中...',
      mask: true
    })
  }
  
  return new Promise((resolve, reject) => {
    const token = uni.getStorageSync('token')
    
    // 调用uni.downloadFile下载文件
    uni.downloadFile({
      url: fullUrl,
      header: {
        'Authorization': token ? `Bearer ${token}` : '',
        ...options.header
      },
      success: (res) => {
        // 隐藏加载中
        if (options.loading !== false) {
          uni.hideLoading()
        }
        
        if (res.statusCode === 200) {
          // 下载成功，返回临时文件路径
          resolve(res.tempFilePath)
        } else {
          // 处理HTTP错误
          const errorMsg = `文件下载失败(${res.statusCode})`
          uni.showToast({
            title: errorMsg,
            icon: 'none'
          })
          reject(new Error(errorMsg))
        }
      },
      fail: (error) => {
        // 隐藏加载中
        if (options.loading !== false) {
          uni.hideLoading()
        }
        
        // 处理下载失败
        const errorMsg = error.errMsg || '文件下载失败'
        uni.showToast({
          title: errorMsg,
          icon: 'none'
        })
        reject(error)
      },
      // 可选的进度回调
      ...(options.onProgressUpdate ? { onProgressUpdate: options.onProgressUpdate } : {})
    })
  })
}